Personal Computer World 2009 February/PCWFEB09.iso/Software/Resources/Chat & Communication/Digsby build 37/digsby_setup.exe/lib/util/primitives/mapping.pyo

Python Compiled Bytecode | 2008-10-13 | 16KB | 498 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.5)

from funcs import isiterable
from functional import AttrChain
from itertools import tee

def fmt_to_dict(delim1, delim2):

    class dictifier('dictifier', (dict,)):

        def __init__(self, *a, **k):
            if a and isinstance(a[0], basestring):
                dict.__init__(self, self.parse(a[0]), *a[1:], **k)
            else:
                dict.__init__(self, *a, **k)


        def parse(cls, s):
            return (tuple,)((lambda .0: for entry in .0:
entry.strip().split(delim2, 1))(s.split(delim1)))

        parse = (None, classmethod)(parse)

        def __str__(self):
            return (delim1.join,)((lambda .0: for i in .0:
delim2.join(i))(self.items()))


    return dictifier


def dictreverse(mapping):
    return dict((lambda .0: for key, value in .0:
(value, key))(mapping.iteritems()))


def dictadd(dict_a, dict_b):
    result = dict(dict_a)
    result.update(dict_b)
    return result


def dictsub(a, b):
    a = a.copy()
    for key in b:
        a.pop(key, None)

    return a


def dictdiff(defaults, user):
    diff = { }
    for k, v in user.iteritems():
        if k not in defaults or v != defaults[k]:
            diff[k] = v
            continue

    return diff


def intdictdiff(start, end):
    keys = set(start.keys()) | set(end.keys())
    out = { }
    for key in keys:
        startval = start.get(key, 0)
        endval = end.get(key, 0)
        outval = endval - startval
        if outval:
            out[key] = outval
            continue

    return out


class DictChain(AttrChain, dict):

    def __init__(self, *args, **kwargs):
        dict.__init__(self, *args, **kwargs)
        AttrChain.__init__(self, 'base', self.__getattr2__)


    def __getattr2__(self, key):
        keys = None if isinstance(key, basestring) else key
        next = self[keys[0]]
        if len(keys) > 1 and isinstance(next, DictChain):
            return dict.__getattribute__(next, '__getattr2__')(keys[1:])
        elif keys:

            try:
                returner = next
            except:
                return self['generic'][keys[0]]

            if isinstance(returner, DictChain):
                return returner['value']
            else:
                return returner
        else:
            return self['value']



class Storage(dict):

    def __getattr__(self, key, ga = dict.__getattribute__, gi = dict.__getitem__):

        try:
            return ga(self, key)
        except AttributeError:

            try:
                return gi(self, key)
            except KeyError:
                msg = repr(key)
                if len(self) <= 20:
                    keys = sorted(self.keys())
                    msg += '\n  (%d existing keys: ' % len(keys) + str(keys) + ')'

                raise AttributeError, msg
            except:
                None<EXCEPTION MATCH>KeyError


            None<EXCEPTION MATCH>KeyError



    def __setattr__(self, key, value):
        self[key] = value


    def copy(self):
        return type(self)(self)


Storage.__module__ = 'util.primitives'

def dictrecurse(newtype):

    def recurser(_d, forbidden = (None, ())):
        if not hasattr(_d, 'keys'):
            pformat = pformat
            import pprint
            raise TypeError('what is?\n%s' % pformat(_d))

        for k in _d:
            if isinstance(_d[k], dict):
                _d[k] = recurser(_d[k])
                continue
            if isiterable(_d[k]) and not isinstance(_d[k], forbidden + (basestring,)):
                _d[k] = (list,)((lambda .0: for item in .0:
None if isinstance(item, dict) else item)(_d[k]))
                continue

        if isinstance(newtype, type):
            return None if isinstance(_d, newtype) else newtype(_d)
        else:
            return newtype(_d)

    return recurser

to_storage = dictrecurse(Storage)

def from_storage(d):
    for k, v in d.items():
        None if isinstance(v, Storage) else []

    return None if type(d) is dict else dict(d)


def lookup_table(*a, **d):
    d = dict(*a, **d)
    d.update(dictreverse(d))
    return to_storage(d)


class no_case_dict(dict):

    def __getitem__(self, attr, get = dict.__getitem__):
        return get(self, attr.lower())


    def __setitem__(self, attr, val):
        return dict.__setitem__(self, attr.lower(), val)


    def __delitem__(self, key):
        return dict.__delitem__(self, key.lower())


    def __contains__(self, attr):
        return dict.__contains__(self, attr.lower())


    def setdefault(self, attr, default):

        try:
            return dict.__getitem__(self, attr.lower())
        except KeyError:
            dict.__setitem__(self, attr.lower(), default)
            return default



    def pop(self, k, x = None):
        return dict.pop(self, k.lower(), x)



def stringify_dict(dict):
    new = { }
    for k, v in dict.items():
        if isinstance(k, basestring):
            new[str(k)] = v
            continue
        new[k] = v

    return new


class odict(dict):

    def __init__(self, d = None):
        if d is None:
            d = { }


        try:
            t = d.items()
            self._keys = [ k for k, _v in t ]
            dict.__init__(self, t)
        except:
            (one, two, three) = tee(d, 3)

            try:
                self._keys = [ k for k, _v in one ]
            except:
                self._keys = [ k for k in two ]

            [](dict.__init__, self if isinstance(d, dict) else three)



    def __delitem__(self, key):
        dict.__delitem__(self, key)
        self._keys.remove(key)


    def __setitem__(self, key, item):
        dict.__setitem__(self, key, item)
        if not hasattr(self, '_keys'):
            self._keys = [
                key]

        if key not in self._keys:
            self._keys.append(key)


    __iter__ = property((lambda self: self._keys.__iter__))

    def clear(self):
        dict.clear(self)
        self._keys = []


    def pop(self, k, defval = sentinel):

        try:
            val = dict.pop(self, k)
        except KeyError:
            if defval is sentinel:
                raise
            else:
                return defval
        except:
            defval is sentinel

        self._keys.remove(k)
        return val


    def iteritems(self):
        for i in self._keys:

            try:
                yield (i, self[i])
            continue
            except KeyError:
                print 'fake keys', self._keys
                print 'real keys', self.keys()
                raise
                continue





    def items(self):
        return list(self.iteritems())


    def keys(self):
        return self._keys


    def popitem(self):
        if len(self._keys) == 0:
            raise KeyError('dictionary is empty')
        else:
            key = self._keys[-1]
            val = self[key]
            del self[key]
            return (key, val)


    def setdefault(self, key, failobj = None):
        ret = dict.setdefault(self, key, failobj)
        if key not in self._keys:
            self._keys.append(key)

        return ret


    def update(self, d):

        try:
            for key in d.keys():
                if not self.has_key(key):
                    self._keys.append(key)
                    continue
        except AttributeError:
            for k, v in d:
                self[k] = v

            return None

        dict.update(self, d)


    def values(self):
        for i in self._keys:
            yield self[i]



    def move(self, key, index):

        try:
            cur = self._keys.index(key)
        except ValueError:
            raise KeyError(key)

        self._keys.insert(index, key)
        if cur >= index:
            cur = cur + 1

        del self._keys[cur]


    def index(self, key):
        if not self.has_key(key):
            raise KeyError(key)

        return self._keys.index(key)



class LazySortedDict(odict):

    def _get_keys(self):

        try:
            self._real_keys = sorted(self._real_keys)
        except AttributeError:
            self._real_keys = []

        return self._real_keys


    def _set_keys(self, keys):
        self._real_keys = sorted(keys)


    def copy(self):
        return type(self)(self)

    _keys = property(_get_keys, _set_keys)


class ostorage(odict, Storage):

    def __getattr__(self, attr):
        if attr == '_keys':
            return odict.__getattr__(self, '_keys')
        else:
            return Storage.__getattr__(self, attr)


    def __setattr__(self, attr, val):
        if attr == '_keys':
            return odict.__setattr__(self, attr, val)
        else:
            return Storage.__setattr__(self, attr, val)



def groupify(seq, keys = None, whitelist = True, mapclass = odict):
    retval = [
        mapclass()]
    idx = 0
    for k, v in seq:
        if keys and whitelist ^ (k in keys):
            continue

        if k in retval[idx]:
            retval.append(mapclass())
            idx += 1

        retval[idx][k] = v

    if not retval[0]:
        return []

    return retval


class FilterDict(dict):

    def __init__(self, filterfunc, d = None, **kw):
        if d is None:
            d = { }

        dict.__init__(self)
        d.update(kw)
        dict.__setattr__(self, 'ff', filterfunc)
        for k, v in d.iteritems():
            self.__setitem__(k, v)



    def __getitem__(self, key):
        return dict.__getitem__(self, self.ff(key))


    def __delitem__(self, key):
        return dict.__delitem__(self, self.ff(key))


    def __contains__(self, key):
        return dict.__contains__(self, self.ff(key))


    def __setitem__(self, key, newval):
        return dict.__setitem__(self, self.ff(key), newval)



class LowerDict(FilterDict):

    def __init__(self, *a, **k):

        def filterfunc(x):

            try:
                x = x.lower()
            except:
                pass

            return x

        FilterDict.__init__(self, filterfunc, *a, **k)


recurse_lower = dictrecurse(LowerDict)

class LowerStorage(LowerDict, Storage):

    def __init__(self, *a, **k):
        Storage.__init__(self)
        LowerDict.__init__(self, *a, **k)


recurse_lower_storage = dictrecurse(LowerStorage)

def odict_from_dictlist(seq):
    od = odict()
    for subdict in seq:
        key = subdict.keys()[0]
        od[key] = subdict[key]

    return od

if __name__ == '__main__':
    import doctest
    doctest.testmod(verbose = True)